// Copyright (c) 2012 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "ui/base/l10n/l10n_util.h"

#include <algorithm>
#include <cstdlib>
#include <iterator>
#include <string>

#include "base/command_line.h"
#include "base/compiler_specific.h"
#include "base/files/file_util.h"
#include "base/i18n/file_util_icu.h"
#include "base/i18n/message_formatter.h"
#include "base/i18n/rtl.h"
#include "base/i18n/string_compare.h"
#include "base/lazy_instance.h"
#include "base/macros.h"
#include "base/memory/scoped_ptr.h"
#include "base/strings/string_number_conversions.h"
#include "base/strings/string_split.h"
#include "base/strings/string_util.h"
#include "base/strings/stringprintf.h"
#include "base/strings/sys_string_conversions.h"
#include "base/strings/utf_string_conversions.h"
#include "build/build_config.h"
#include "third_party/icu/source/common/unicode/rbbi.h"
#include "third_party/icu/source/common/unicode/uloc.h"
#include "ui/base/l10n/l10n_util_collator.h"
#include "ui/base/resource/resource_bundle.h"
#include "ui/base/ui_base_paths.h"

#if defined(OS_ANDROID)
#include "base/android/locale_utils.h"
#include "ui/base/l10n/l10n_util_android.h"
#endif

#if defined(USE_GLIB)
#include <glib.h>
#endif

#if defined(OS_WIN)
#include "ui/base/l10n/l10n_util_win.h"
#endif // OS_WIN

namespace {

static const char* const kAcceptLanguageList[] = {
    "af", // Afrikaans
    "am", // Amharic
    "ar", // Arabic
    "az", // Azerbaijani
    "be", // Belarusian
    "bg", // Bulgarian
    "bh", // Bihari
    "bn", // Bengali
    "br", // Breton
    "bs", // Bosnian
    "ca", // Catalan
    "ckb", // Kurdish (Arabci),  Sorani
    "co", // Corsican
    "cs", // Czech
    "cy", // Welsh
    "da", // Danish
    "de", // German
    "de-AT", // German (Austria)
    "de-CH", // German (Switzerland)
    "de-DE", // German (Germany)
    "de-LI", // German (Liechtenstein)
    "el", // Greek
    "en", // English
    "en-AU", // English (Australia)
    "en-CA", // English (Canada)
    "en-GB", // English (UK)
    "en-NZ", // English (New Zealand)
    "en-US", // English (US)
    "en-ZA", // English (South Africa)
    "eo", // Esperanto
    // TODO(jungshik) : Do we want to list all es-Foo for Latin-American
    // Spanish speaking countries?
    "es", // Spanish
    "es-419", // Spanish (Latin America)
    "et", // Estonian
    "eu", // Basque
    "fa", // Persian
    "fi", // Finnish
    "fil", // Filipino
    "fo", // Faroese
    "fr", // French
    "fr-CA", // French (Canada)
    "fr-CH", // French (Switzerland)
    "fr-FR", // French (France)
    "fy", // Frisian
    "ga", // Irish
    "gd", // Scots Gaelic
    "gl", // Galician
    "gn", // Guarani
    "gu", // Gujarati
    "ha", // Hausa
    "haw", // Hawaiian
    "he", // Hebrew
    "hi", // Hindi
    "hr", // Croatian
    "hu", // Hungarian
    "hy", // Armenian
    "ia", // Interlingua
    "id", // Indonesian
    "is", // Icelandic
    "it", // Italian
    "it-CH", // Italian (Switzerland)
    "it-IT", // Italian (Italy)
    "ja", // Japanese
    "jw", // Javanese
    "ka", // Georgian
    "kk", // Kazakh
    "km", // Cambodian
    "kn", // Kannada
    "ko", // Korean
    "ku", // Kurdish
    "ky", // Kyrgyz
    "la", // Latin
    "ln", // Lingala
    "lo", // Laothian
    "lt", // Lithuanian
    "lv", // Latvian
    "mk", // Macedonian
    "ml", // Malayalam
    "mn", // Mongolian
    "mo", // Moldavian
    "mr", // Marathi
    "ms", // Malay
    "mt", // Maltese
    "nb", // Norwegian (Bokmal)
    "ne", // Nepali
    "nl", // Dutch
    "nn", // Norwegian (Nynorsk)
    "no", // Norwegian
    "oc", // Occitan
    "om", // Oromo
    "or", // Oriya
    "pa", // Punjabi
    "pl", // Polish
    "ps", // Pashto
    "pt", // Portuguese
    "pt-BR", // Portuguese (Brazil)
    "pt-PT", // Portuguese (Portugal)
    "qu", // Quechua
    "rm", // Romansh
    "ro", // Romanian
    "ru", // Russian
    "sd", // Sindhi
    "sh", // Serbo-Croatian
    "si", // Sinhalese
    "sk", // Slovak
    "sl", // Slovenian
    "sn", // Shona
    "so", // Somali
    "sq", // Albanian
    "sr", // Serbian
    "st", // Sesotho
    "su", // Sundanese
    "sv", // Swedish
    "sw", // Swahili
    "ta", // Tamil
    "te", // Telugu
    "tg", // Tajik
    "th", // Thai
    "ti", // Tigrinya
    "tk", // Turkmen
    "to", // Tonga
    "tr", // Turkish
    "tt", // Tatar
    "tw", // Twi
    "ug", // Uighur
    "uk", // Ukrainian
    "ur", // Urdu
    "uz", // Uzbek
    "vi", // Vietnamese
    "xh", // Xhosa
    "yi", // Yiddish
    "yo", // Yoruba
    "zh", // Chinese
    "zh-CN", // Chinese (Simplified)
    "zh-TW", // Chinese (Traditional)
    "zu", // Zulu
};

// Returns true if |locale_name| has an alias in the ICU data file.
bool IsDuplicateName(const std::string& locale_name)
{
    static const char* const kDuplicateNames[] = {
        "en",
        "en_001",
        "pt", // pt-BR and pt-PT are used.
        "zh",
        "zh_hans_cn",
        "zh_hant_hk",
        "zh_hant_mo",
        "zh_hans_sg",
        "zh_hant_tw"
    };

    // Skip all the es_Foo other than es_419 for now.
    if (base::StartsWith(locale_name, "es_",
            base::CompareCase::INSENSITIVE_ASCII))
        return !base::EndsWith(locale_name, "419", base::CompareCase::SENSITIVE);

    for (size_t i = 0; i < arraysize(kDuplicateNames); ++i) {
        if (base::EqualsCaseInsensitiveASCII(kDuplicateNames[i], locale_name))
            return true;
    }
    return false;
}

// We added 30+ minimally populated locales with only a few entries
// (exemplar character set, script, writing direction and its own
// lanaguage name). These locales have to be distinguished from the
// fully populated locales to which Chrome is localized.
bool IsLocalePartiallyPopulated(const std::string& locale_name)
{
    // For partially populated locales, even the translation for "English"
    // is not available. A more robust/elegant way to check is to add a special
    // field (say, 'isPartial' to our version of ICU locale files) and
    // check its value, but this hack seems to work well.
    return !l10n_util::IsLocaleNameTranslated("en", locale_name);
}

#if !defined(OS_MACOSX)
bool IsLocaleAvailable(const std::string& locale)
{
    // If locale has any illegal characters in it, we don't want to try to
    // load it because it may be pointing outside the locale data file directory.
    if (!base::i18n::IsFilenameLegal(base::ASCIIToUTF16(locale)))
        return false;

    // IsLocalePartiallyPopulated() can be called here for an early return w/o
    // checking the resource availability below. It'd help when Chrome is run
    // under a system locale Chrome is not localized to (e.g.Farsi on Linux),
    // but it'd slow down the start up time a little bit for locales Chrome is
    // localized to. So, we don't call it here.
    if (!l10n_util::IsLocaleSupportedByOS(locale))
        return false;

    // If the ResourceBundle is not yet initialized, return false to avoid the
    // CHECK failure in ResourceBundle::GetSharedInstance().
    if (!ResourceBundle::HasSharedInstance())
        return false;

    // TODO(hshi): make ResourceBundle::LocaleDataPakExists() a static function
    // so that this can be invoked without initializing the global instance.
    // See crbug.com/230432: CHECK failure in GetUserDataDir().
    return ResourceBundle::GetSharedInstance().LocaleDataPakExists(locale);
}
#endif

// On Linux, the text layout engine Pango determines paragraph directionality
// by looking at the first strongly-directional character in the text. This
// means text such as "Google Chrome foo bar..." will be layed out LTR even
// if "foo bar" is RTL. So this function prepends the necessary RLM in such
// cases.
void AdjustParagraphDirectionality(base::string16* paragraph)
{
#if defined(OS_POSIX) && !defined(OS_MACOSX) && !defined(OS_ANDROID)
    if (base::i18n::IsRTL() && base::i18n::StringContainsStrongRTLChars(*paragraph)) {
        paragraph->insert(0, 1,
            static_cast<base::char16>(base::i18n::kRightToLeftMark));
    }
#endif
}

struct AvailableLocalesTraits
    : base::DefaultLazyInstanceTraits<std::vector<std::string>> {
    static std::vector<std::string>* New(void* instance)
    {
        std::vector<std::string>* locales = base::DefaultLazyInstanceTraits<std::vector<std::string>>::New(
            instance);
        int num_locales = uloc_countAvailable();
        for (int i = 0; i < num_locales; ++i) {
            std::string locale_name = uloc_getAvailable(i);
            // Filter out the names that have aliases.
            if (IsDuplicateName(locale_name))
                continue;
            // Filter out locales for which we have only partially populated data
            // and to which Chrome is not localized.
            if (IsLocalePartiallyPopulated(locale_name))
                continue;
            if (!l10n_util::IsLocaleSupportedByOS(locale_name))
                continue;
            // Normalize underscores to hyphens because that's what our locale files
            // use.
            std::replace(locale_name.begin(), locale_name.end(), '_', '-');

            // Map the Chinese locale names over to zh-CN and zh-TW.
            if (base::LowerCaseEqualsASCII(locale_name, "zh-hans")) {
                locale_name = "zh-CN";
            } else if (base::LowerCaseEqualsASCII(locale_name, "zh-hant")) {
                locale_name = "zh-TW";
            }
            locales->push_back(locale_name);
        }

        return locales;
    }
};

base::LazyInstance<std::vector<std::string>, AvailableLocalesTraits>
    g_available_locales = LAZY_INSTANCE_INITIALIZER;

} // namespace

namespace l10n_util {

std::string GetLanguage(const std::string& locale)
{
    const std::string::size_type hyphen_pos = locale.find('-');
    return std::string(locale, 0, hyphen_pos);
}

bool CheckAndResolveLocale(const std::string& locale,
    std::string* resolved_locale)
{
#if defined(OS_MACOSX)
    NOTIMPLEMENTED();
    return false;
#else
    if (IsLocaleAvailable(locale)) {
        *resolved_locale = locale;
        return true;
    }

    // If there's a variant, skip over it so we can try without the region
    // code.  For example, ca_ES@valencia should cause us to try ca@valencia
    // before ca.
    std::string::size_type variant_pos = locale.find('@');
    if (variant_pos != std::string::npos)
        return false;

    // If the locale matches language but not country, use that instead.
    // TODO(jungshik) : Nothing is done about languages that Chrome
    // does not support but available on Windows. We fall
    // back to en-US in GetApplicationLocale so that it's a not critical,
    // but we can do better.
    const std::string lang(GetLanguage(locale));
    if (lang.size() < locale.size()) {
        std::string region(locale, lang.size() + 1);
        std::string tmp_locale(lang);
        // Map es-RR other than es-ES to es-419 (Chrome's Latin American
        // Spanish locale).
        if (base::LowerCaseEqualsASCII(lang, "es") && !base::LowerCaseEqualsASCII(region, "es")) {
            tmp_locale.append("-419");
        } else if (base::LowerCaseEqualsASCII(lang, "zh")) {
            // Map zh-HK and zh-MO to zh-TW. Otherwise, zh-FOO is mapped to zh-CN.
            if (base::LowerCaseEqualsASCII(region, "hk") || base::LowerCaseEqualsASCII(region, "mo")) { // Macao
                tmp_locale.append("-TW");
            } else {
                tmp_locale.append("-CN");
            }
        } else if (base::LowerCaseEqualsASCII(lang, "en")) {
            // Map Australian, Canadian, New Zealand and South African English
            // to British English for now.
            // TODO(jungshik): en-CA may have to change sides once
            // we have OS locale separate from app locale (Chrome's UI language).
            if (base::LowerCaseEqualsASCII(region, "au") || base::LowerCaseEqualsASCII(region, "ca") || base::LowerCaseEqualsASCII(region, "nz") || base::LowerCaseEqualsASCII(region, "za")) {
                tmp_locale.append("-GB");
            } else {
                tmp_locale.append("-US");
            }
        }
        if (IsLocaleAvailable(tmp_locale)) {
            resolved_locale->swap(tmp_locale);
            return true;
        }
    }

    // Google updater uses no, tl, iw and en for our nb, fil, he, and en-US.
    struct {
        const char* source;
        const char* dest;
    } alias_map[] = {
        { "no", "nb" },
        { "tl", "fil" },
        { "iw", "he" },
        { "en", "en-US" },
    };

    for (size_t i = 0; i < arraysize(alias_map); ++i) {
        if (base::LowerCaseEqualsASCII(lang, alias_map[i].source)) {
            std::string tmp_locale(alias_map[i].dest);
            if (IsLocaleAvailable(tmp_locale)) {
                resolved_locale->swap(tmp_locale);
                return true;
            }
        }
    }

    return false;
#endif
}

std::string GetApplicationLocaleInternal(const std::string& pref_locale)
{
#if defined(OS_MACOSX)

    // Use any override (Cocoa for the browser), otherwise use the preference
    // passed to the function.
    std::string app_locale = l10n_util::GetLocaleOverride();
    if (app_locale.empty())
        app_locale = pref_locale;

    // The above should handle all of the cases Chrome normally hits, but for some
    // unit tests, we need something to fall back too.
    if (app_locale.empty())
        app_locale = "en-US";

    return app_locale;

#else

    std::string resolved_locale;
    std::vector<std::string> candidates;

    // We only use --lang and the app pref on Windows.  On Linux, we only
    // look at the LC_*/LANG environment variables.  We do, however, pass --lang
    // to renderer and plugin processes so they know what language the parent
    // process decided to use.

#if defined(OS_WIN)

    // First, try the preference value.
    if (!pref_locale.empty())
        candidates.push_back(base::i18n::GetCanonicalLocale(pref_locale));

    // Next, try the overridden locale.
    const std::vector<std::string>& languages = l10n_util::GetLocaleOverrides();
    if (!languages.empty()) {
        candidates.reserve(candidates.size() + languages.size());
        std::transform(languages.begin(), languages.end(),
            std::back_inserter(candidates),
            &base::i18n::GetCanonicalLocale);
    } else {
        // If no override was set, defer to ICU
        candidates.push_back(base::i18n::GetConfiguredLocale());
    }

#elif defined(OS_ANDROID)

    // On Android, query java.util.Locale for the default locale.
    candidates.push_back(base::android::GetDefaultLocale());

#elif defined(USE_GLIB) && !defined(OS_CHROMEOS)

    // GLib implements correct environment variable parsing with
    // the precedence order: LANGUAGE, LC_ALL, LC_MESSAGES and LANG.
    // We used to use our custom parsing code along with ICU for this purpose.
    // If we have a port that does not depend on GTK, we have to
    // restore our custom code for that port.
    const char* const* languages = g_get_language_names();
    DCHECK(languages); // A valid pointer is guaranteed.
    DCHECK(*languages); // At least one entry, "C", is guaranteed.

    for (; *languages != NULL; ++languages) {
        candidates.push_back(base::i18n::GetCanonicalLocale(*languages));
    }

#else

    // By default, use the application locale preference. This applies to ChromeOS
    // and linux systems without glib.
    if (!pref_locale.empty())
        candidates.push_back(pref_locale);

#endif

    std::vector<std::string>::const_iterator i = candidates.begin();
    for (; i != candidates.end(); ++i) {
        if (CheckAndResolveLocale(*i, &resolved_locale)) {
            return resolved_locale;
        }
    }

    // Fallback on en-US.
    const std::string fallback_locale("en-US");
    if (IsLocaleAvailable(fallback_locale)) {
        return fallback_locale;
    }

    return std::string();

#endif
}

std::string GetApplicationLocale(const std::string& pref_locale,
    bool set_icu_locale)
{
    const std::string locale = GetApplicationLocaleInternal(pref_locale);
    if (set_icu_locale && !locale.empty())
        base::i18n::SetICUDefaultLocale(locale);
    return locale;
}

std::string GetApplicationLocale(const std::string& pref_locale)
{
    return GetApplicationLocale(pref_locale, true /* set_icu_locale */);
}

bool IsLocaleNameTranslated(const char* locale,
    const std::string& display_locale)
{
    base::string16 display_name = l10n_util::GetDisplayNameForLocale(locale, display_locale, false);
    // Because ICU sets the error code to U_USING_DEFAULT_WARNING whether or not
    // uloc_getDisplayName returns the actual translation or the default
    // value (locale code), we have to rely on this hack to tell whether
    // the translation is available or not.  If ICU doesn't have a translated
    // name for this locale, GetDisplayNameForLocale will just return the
    // locale code.
    return !base::IsStringASCII(display_name) || base::UTF16ToASCII(display_name) != locale;
}

base::string16 GetDisplayNameForLocale(const std::string& locale,
    const std::string& display_locale,
    bool is_for_ui)
{
    std::string locale_code = locale;
    // Internally, we use the language code of zh-CN and zh-TW, but we want the
    // display names to be Chinese (Simplified) and Chinese (Traditional) instead
    // of Chinese (China) and Chinese (Taiwan).
    // Translate uses "tl" (Tagalog) to mean "fil" (Filipino) until Google
    // translate is changed to understand "fil". Make "tl" alias to "fil".
    if (locale_code == "zh-CN")
        locale_code = "zh-Hans";
    else if (locale_code == "zh-TW")
        locale_code = "zh-Hant";
    else if (locale_code == "tl")
        locale_code = "fil";
    else if (locale_code == "mo")
        locale_code = "ro-MD";

    base::string16 display_name;
#if defined(OS_ANDROID)
    // Use Java API to get locale display name so that we can remove most of
    // the lang data from icu data to reduce binary size, except for zh-Hans and
    // zh-Hant because the current Android Java API doesn't support scripts.
    // TODO(wangxianzhu): remove the special handling of zh-Hans and zh-Hant once
    // Android Java API supports scripts.
    if (!base::StartsWith(locale_code, "zh-Han", base::CompareCase::SENSITIVE)) {
        display_name = GetDisplayNameForLocale(locale_code, display_locale);
    } else
#endif
    {
        UErrorCode error = U_ZERO_ERROR;
        const int kBufferSize = 1024;

        int actual_size = uloc_getDisplayName(
            locale_code.c_str(), display_locale.c_str(),
            base::WriteInto(&display_name, kBufferSize), kBufferSize - 1, &error);
        DCHECK(U_SUCCESS(error));
        display_name.resize(actual_size);
    }

    // Add directional markup so parentheses are properly placed.
    if (is_for_ui && base::i18n::IsRTL())
        base::i18n::AdjustStringForLocaleDirection(&display_name);
    return display_name;
}

base::string16 GetDisplayNameForCountry(const std::string& country_code,
    const std::string& display_locale)
{
    return GetDisplayNameForLocale("_" + country_code, display_locale, false);
}

std::string NormalizeLocale(const std::string& locale)
{
    std::string normalized_locale(locale);
    std::replace(normalized_locale.begin(), normalized_locale.end(), '-', '_');

    return normalized_locale;
}

void GetParentLocales(const std::string& current_locale,
    std::vector<std::string>* parent_locales)
{
    std::string locale(NormalizeLocale(current_locale));

    const int kNameCapacity = 256;
    char parent[kNameCapacity];
    base::strlcpy(parent, locale.c_str(), kNameCapacity);
    parent_locales->push_back(parent);
    UErrorCode err = U_ZERO_ERROR;
    while (uloc_getParent(parent, parent, kNameCapacity, &err) > 0) {
        if (U_FAILURE(err))
            break;
        parent_locales->push_back(parent);
    }
}

bool IsValidLocaleSyntax(const std::string& locale)
{
    // Check that the length is plausible.
    if (locale.size() < 2 || locale.size() >= ULOC_FULLNAME_CAPACITY)
        return false;

    // Strip off the part after an '@' sign, which might contain keywords,
    // as in en_IE@currency=IEP or fr@collation=phonebook;calendar=islamic-civil.
    // We don't validate that part much, just check that there's at least one
    // equals sign in a plausible place. Normalize the prefix so that hyphens
    // are changed to underscores.
    std::string prefix = NormalizeLocale(locale);
    size_t split_point = locale.find("@");
    if (split_point != std::string::npos) {
        std::string keywords = locale.substr(split_point + 1);
        prefix = locale.substr(0, split_point);

        size_t equals_loc = keywords.find("=");
        if (equals_loc == std::string::npos || equals_loc < 1 || equals_loc > keywords.size() - 2)
            return false;
    }

    // Check that all characters before the at-sign are alphanumeric or
    // underscore.
    for (size_t i = 0; i < prefix.size(); i++) {
        char ch = prefix[i];
        if (!base::IsAsciiAlpha(ch) && !base::IsAsciiDigit(ch) && ch != '_')
            return false;
    }

    // Check that the initial token (before the first hyphen/underscore)
    // is 1 - 3 alphabetical characters (a language tag).
    for (size_t i = 0; i < prefix.size(); i++) {
        char ch = prefix[i];
        if (ch == '_') {
            if (i < 1 || i > 3)
                return false;
            break;
        }
        if (!base::IsAsciiAlpha(ch))
            return false;
    }

    // Check that the all tokens after the initial token are 1 - 8 characters.
    // (Tokenize/StringTokenizer don't work here, they collapse multiple
    // delimiters into one.)
    int token_len = 0;
    int token_index = 0;
    for (size_t i = 0; i < prefix.size(); i++) {
        if (prefix[i] != '_') {
            token_len++;
            continue;
        }

        if (token_index > 0 && (token_len < 1 || token_len > 8)) {
            return false;
        }
        token_index++;
        token_len = 0;
    }
    if (token_index == 0 && (token_len < 1 || token_len > 3)) {
        return false;
    } else if (token_len < 1 || token_len > 8) {
        return false;
    }

    return true;
}

std::string GetStringUTF8(int message_id)
{
    return base::UTF16ToUTF8(GetStringUTF16(message_id));
}

base::string16 GetStringUTF16(int message_id)
{
    ResourceBundle& rb = ResourceBundle::GetSharedInstance();
    base::string16 str = rb.GetLocalizedString(message_id);
    AdjustParagraphDirectionality(&str);

    return str;
}

base::string16 GetStringFUTF16(int message_id,
    const std::vector<base::string16>& replacements,
    std::vector<size_t>* offsets)
{
    // TODO(tc): We could save a string copy if we got the raw string as
    // a StringPiece and were able to call ReplaceStringPlaceholders with
    // a StringPiece format string and base::string16 substitution strings.  In
    // practice, the strings should be relatively short.
    ResourceBundle& rb = ResourceBundle::GetSharedInstance();
    const base::string16& format_string = rb.GetLocalizedString(message_id);

#ifndef NDEBUG
    // Make sure every replacement string is being used, so we don't just
    // silently fail to insert one. If |offsets| is non-NULL, then don't do this
    // check as the code may simply want to find the placeholders rather than
    // actually replacing them.
    if (!offsets) {
        std::string utf8_string = base::UTF16ToUTF8(format_string);

        // $9 is the highest allowed placeholder.
        for (size_t i = 0; i < 9; ++i) {
            bool placeholder_should_exist = replacements.size() > i;

            std::string placeholder = base::StringPrintf("$%d", static_cast<int>(i + 1));
            size_t pos = utf8_string.find(placeholder.c_str());
            if (placeholder_should_exist) {
                DCHECK_NE(std::string::npos, pos) << " Didn't find a " << placeholder << " placeholder in " << utf8_string;
            } else {
                DCHECK_EQ(std::string::npos, pos) << " Unexpectedly found a " << placeholder << " placeholder in " << utf8_string;
            }
        }
    }
#endif

    base::string16 formatted = base::ReplaceStringPlaceholders(
        format_string, replacements, offsets);
    AdjustParagraphDirectionality(&formatted);

    return formatted;
}

std::string GetStringFUTF8(int message_id,
    const base::string16& a)
{
    return base::UTF16ToUTF8(GetStringFUTF16(message_id, a));
}

std::string GetStringFUTF8(int message_id,
    const base::string16& a,
    const base::string16& b)
{
    return base::UTF16ToUTF8(GetStringFUTF16(message_id, a, b));
}

std::string GetStringFUTF8(int message_id,
    const base::string16& a,
    const base::string16& b,
    const base::string16& c)
{
    return base::UTF16ToUTF8(GetStringFUTF16(message_id, a, b, c));
}

std::string GetStringFUTF8(int message_id,
    const base::string16& a,
    const base::string16& b,
    const base::string16& c,
    const base::string16& d)
{
    return base::UTF16ToUTF8(GetStringFUTF16(message_id, a, b, c, d));
}

base::string16 GetStringFUTF16(int message_id,
    const base::string16& a)
{
    std::vector<base::string16> replacements;
    replacements.push_back(a);
    return GetStringFUTF16(message_id, replacements, NULL);
}

base::string16 GetStringFUTF16(int message_id,
    const base::string16& a,
    const base::string16& b)
{
    return GetStringFUTF16(message_id, a, b, NULL);
}

base::string16 GetStringFUTF16(int message_id,
    const base::string16& a,
    const base::string16& b,
    const base::string16& c)
{
    std::vector<base::string16> replacements;
    replacements.push_back(a);
    replacements.push_back(b);
    replacements.push_back(c);
    return GetStringFUTF16(message_id, replacements, NULL);
}

base::string16 GetStringFUTF16(int message_id,
    const base::string16& a,
    const base::string16& b,
    const base::string16& c,
    const base::string16& d)
{
    std::vector<base::string16> replacements;
    replacements.push_back(a);
    replacements.push_back(b);
    replacements.push_back(c);
    replacements.push_back(d);
    return GetStringFUTF16(message_id, replacements, NULL);
}

base::string16 GetStringFUTF16(int message_id,
    const base::string16& a,
    const base::string16& b,
    const base::string16& c,
    const base::string16& d,
    const base::string16& e)
{
    std::vector<base::string16> replacements;
    replacements.push_back(a);
    replacements.push_back(b);
    replacements.push_back(c);
    replacements.push_back(d);
    replacements.push_back(e);
    return GetStringFUTF16(message_id, replacements, NULL);
}

base::string16 GetStringFUTF16(int message_id,
    const base::string16& a,
    size_t* offset)
{
    DCHECK(offset);
    std::vector<size_t> offsets;
    std::vector<base::string16> replacements;
    replacements.push_back(a);
    base::string16 result = GetStringFUTF16(message_id, replacements, &offsets);
    DCHECK(offsets.size() == 1);
    *offset = offsets[0];
    return result;
}

base::string16 GetStringFUTF16(int message_id,
    const base::string16& a,
    const base::string16& b,
    std::vector<size_t>* offsets)
{
    std::vector<base::string16> replacements;
    replacements.push_back(a);
    replacements.push_back(b);
    return GetStringFUTF16(message_id, replacements, offsets);
}

base::string16 GetStringFUTF16Int(int message_id, int a)
{
    return GetStringFUTF16(message_id, base::UTF8ToUTF16(base::IntToString(a)));
}

base::string16 GetStringFUTF16Int(int message_id, int64_t a)
{
    return GetStringFUTF16(message_id, base::UTF8ToUTF16(base::Int64ToString(a)));
}

base::string16 GetPluralStringFUTF16(int message_id, int number)
{
    return base::i18n::MessageFormatter::FormatWithNumberedArgs(
        GetStringUTF16(message_id), number);
}

std::string GetPluralStringFUTF8(int message_id, int number)
{
    return base::UTF16ToUTF8(GetPluralStringFUTF16(message_id, number));
}

base::string16 GetSingleOrMultipleStringUTF16(int message_id,
    bool is_multiple)
{
    return base::i18n::MessageFormatter::FormatWithNumberedArgs(
        GetStringUTF16(message_id), is_multiple ? "multiple" : "single");
}

void SortStrings16(const std::string& locale,
    std::vector<base::string16>* strings)
{
    SortVectorWithStringKey(locale, strings, false);
}

const std::vector<std::string>& GetAvailableLocales()
{
    return g_available_locales.Get();
}

void GetAcceptLanguagesForLocale(const std::string& display_locale,
    std::vector<std::string>* locale_codes)
{
    for (size_t i = 0; i < arraysize(kAcceptLanguageList); ++i) {
        if (!l10n_util::IsLocaleNameTranslated(kAcceptLanguageList[i],
                display_locale))
            // TODO(jungshik) : Put them at the of the list with language codes
            // enclosed by brackets instead of skipping.
            continue;
        locale_codes->push_back(kAcceptLanguageList[i]);
    }
}

int GetLocalizedContentsWidthInPixels(int pixel_resource_id)
{
    int width = 0;
    base::StringToInt(l10n_util::GetStringUTF8(pixel_resource_id), &width);
    DCHECK_GT(width, 0);
    return width;
}

const char* const* GetAcceptLanguageListForTesting()
{
    return kAcceptLanguageList;
}

size_t GetAcceptLanguageListSizeForTesting()
{
    return arraysize(kAcceptLanguageList);
}

} // namespace l10n_util
